home *** CD-ROM | disk | FTP | other *** search
/ Aminet 32 / Aminet 32 (1999)(Schatztruhe)[!][Aug 1999].iso / Aminet / game / think / MUIMineSrc.lha / MUIMineSource / FaceButton.c < prev    next >
C/C++ Source or Header  |  1998-12-14  |  12KB  |  434 lines
  1. /*
  2.     MUI custom class for X-Mines Face Button
  3. */
  4.  
  5. #include "MUIMine.h"
  6. #include "FaceButton.h"
  7.  
  8.  
  9. /*
  10.     Instance data
  11. */
  12. struct FaceButtonData
  13. {
  14.     int     Width, Height;          // width and height of button image
  15.     int     ImageIdx;               // index of image to show
  16.     int     SelSaveImageIdx;        // saves the origional index during select
  17.     ULONG   Flags;                  // Flags (see defines below)
  18.     STRPTR  ImageFile;              // name of imagery picture file
  19.     struct Screen * RenderScreen;   // screen bitmap was rendered to
  20.     Object * ImageDTObject;         // picture data type object for imagery
  21.     struct BitMap * ImageBM;        // bitmap containing face imagery
  22. };
  23.  
  24. /*
  25.     defines for FaceButtonData.Flags
  26. */
  27. #define FBDF_NEWIMAGE       0x00000001L // the image file name has changed
  28.  
  29. /*
  30.     defines for defaults 
  31. */
  32. #define DEFAULT_IMAGEFILE (STRPTR)"def_FaceButtonImage"
  33. #define DEFAULT_IMAGEDIR  (STRPTR)"Images"
  34.  
  35.  
  36. /*
  37.     defines for image indexes
  38. */
  39. #define IMAGEIDX_NORMAL     MUIV_FaceButton_ImageIdx_Normal
  40. #define IMAGEIDX_SELECTED   MUIV_FaceButton_ImageIdx_Selected
  41. #define IMAGEIDX_OH         MUIV_FaceButton_ImageIdx_Oh
  42. #define IMAGEIDX_GOOD       MUIV_FaceButton_ImageIdx_Good
  43. #define IMAGEIDX_BAD        MUIV_FaceButton_ImageIdx_Bad
  44.  
  45. #define IMAGE_COUNT         5
  46.  
  47.  
  48. /*
  49.     other defines
  50. */
  51.  
  52.  
  53.  
  54. /*
  55.     private function prototypes
  56. */
  57. static void DeleteImageFileName(struct FaceButtonData * data);
  58. static void SetImageFileName(struct FaceButtonData * data, STRPTR newname);
  59. BOOL InitFaceButtonImageBM(struct FaceButtonData * data, struct Screen * rscreen);
  60. void FreeFaceButtonImageBM(struct FaceButtonData * data);
  61.  
  62.  
  63.  
  64. /*
  65.     function :    OM_NEW method handler for FaceButton class
  66. */
  67. static ULONG mNew(struct IClass *cl, Object *obj, struct opSet *msg)
  68. {
  69.     struct FaceButtonData *data;
  70.     STRPTR fname;
  71.  
  72.     if (!(obj = (Object *)DoSuperMethodA(cl, obj, (APTR)msg)))
  73.     {
  74.         return 0;
  75.     }
  76.  
  77.     data = INST_DATA(cl, obj);
  78.  
  79.     data->Height = data->Width = 0;
  80.     data->ImageIdx = data->SelSaveImageIdx = 0;
  81.     data->Flags = 0;
  82.     data->RenderScreen = NULL;
  83.     data->ImageFile = NULL;
  84.     data->ImageDTObject = NULL;
  85.     data->ImageBM = NULL;
  86.  
  87.     fname = (STRPTR)GetTagData(MUIA_FaceButton_ImageFile, NULL,
  88.                                msg->ops_AttrList);
  89.     SetImageFileName(data, fname);
  90.  
  91.     return (ULONG)obj;
  92. }
  93.  
  94.  
  95. /*
  96.     function :    OM_DELETE method handler for FaceButton class
  97. */
  98. static ULONG mDispose(struct IClass *cl, Object *obj, Msg msg)
  99. {
  100.     struct FaceButtonData *data = INST_DATA(cl, obj);
  101.  
  102.     FreeFaceButtonImageBM(data);
  103.     DeleteImageFileName(data);
  104.  
  105.     return DoSuperMethodA(cl, obj, msg);
  106. }
  107.  
  108.  
  109. /*
  110.     function :    MUIM_Setup method handler for FaceButton class
  111. */
  112. static ULONG mSetup(struct IClass *cl, Object *obj, struct MUIP_Setup * msg)
  113. {
  114.     struct FaceButtonData *data = INST_DATA(cl, obj);
  115.  
  116.     if (!(DoSuperMethodA(cl, obj, (APTR)msg)))
  117.     {
  118.         return FALSE;
  119.     }
  120.  
  121.     if (!InitFaceButtonImageBM(data, msg->RenderInfo->mri_Screen))
  122.     {
  123.         CoerceMethod(cl, obj, MUIM_Cleanup);
  124.         return FALSE;
  125.     }
  126.  
  127.     MUI_RequestIDCMP(obj, IDCMP_MOUSEBUTTONS);
  128.  
  129.     return TRUE;
  130. }
  131.  
  132.  
  133. /*
  134.     function :    MUIM_Cleanup method handler for FaceButton class
  135. */
  136. static ULONG mCleanup(struct IClass *cl, Object *obj, Msg msg)
  137. {
  138. //    struct FaceButtonData *data = INST_DATA(cl, obj);
  139.  
  140.     MUI_RejectIDCMP(obj, IDCMP_MOUSEBUTTONS);
  141.  
  142.     return(DoSuperMethodA(cl, obj, msg));
  143. }
  144.  
  145. /*
  146.     function :    MUIM_AskMinMax method handler for FaceButton class
  147. */
  148. static ULONG mAskMinMax(struct IClass *cl, Object *obj, struct MUIP_AskMinMax *msg)
  149. {
  150.     struct FaceButtonData *data = INST_DATA(cl, obj);
  151.  
  152.     /*
  153.     ** let our superclass first fill in what it thinks about sizes.
  154.     ** this will e.g. add the size of frame and inner spacing.
  155.     */
  156.  
  157.     DoSuperMethodA(cl, obj, (APTR)msg);
  158.  
  159.     /*
  160.     ** now add the values specific to our object. note that we
  161.     ** indeed need to *add* these values, not just set them!
  162.     */
  163.  
  164.     msg->MinMaxInfo->MinWidth  += data->Width;
  165.     msg->MinMaxInfo->DefWidth  += data->Width;
  166.     msg->MinMaxInfo->MaxWidth  += data->Width;
  167.  
  168.     msg->MinMaxInfo->MinHeight += data->Height;
  169.     msg->MinMaxInfo->DefHeight += data->Height;
  170.     msg->MinMaxInfo->MaxHeight += data->Height;
  171.  
  172.     return 0;
  173. }
  174.  
  175.  
  176. /*
  177.     function :    OM_SET method handler for FaceButton class
  178. */
  179. static ULONG mSet(struct IClass *cl, Object *obj, struct opSet * msg)
  180. {
  181.     struct FaceButtonData *data = INST_DATA(cl,obj);
  182.     struct TagItem *tags, *tag;
  183.  
  184.     for (tags = msg->ops_AttrList; tag = NextTagItem(&tags); )
  185.     {
  186.         switch (tag->ti_Tag)
  187.         {
  188.             case MUIA_FaceButton_ImageFile:
  189.                 SetImageFileName(data, (STRPTR)tag->ti_Data);
  190.                 break;
  191.  
  192.             case MUIA_FaceButton_ImageIdx:
  193.                 if (data->ImageIdx != (int)tag->ti_Data)
  194.                 {
  195.                     data->ImageIdx = (int)tag->ti_Data;
  196.                     MUI_Redraw(obj, MADF_DRAWOBJECT);
  197.                 }
  198.                 break;
  199.  
  200.             case MUIA_Selected:
  201.                 if (tag->ti_Data)
  202.                 {
  203.                     data->SelSaveImageIdx = data->ImageIdx;
  204.                     data->ImageIdx = IMAGEIDX_SELECTED;
  205.                 }
  206.                 else
  207.                 {
  208.                     data->ImageIdx = data->SelSaveImageIdx;
  209.                 }
  210.                 MUI_Redraw(obj, MADF_DRAWOBJECT);
  211.                 break;
  212.         }
  213.     }
  214.  
  215.     return DoSuperMethodA(cl, obj, (APTR)msg);
  216. }
  217.  
  218.  
  219. /*
  220.     function :    MUIM_Draw method handler for FaceButton class
  221. */
  222. static ULONG mDraw(struct IClass *cl, Object *obj, struct MUIP_Draw *msg)
  223. {
  224.     struct FaceButtonData *data = INST_DATA(cl, obj);
  225.  
  226.     /*
  227.     ** let our superclass draw itself first, area class would
  228.     ** e.g. draw the frame and clear the whole region. What
  229.     ** it does exactly depends on msg->flags.
  230.     */
  231.  
  232.     DoSuperMethodA(cl,obj,(APTR)msg);
  233.  
  234.     /*
  235.     ** only re-draw if MADF_DRAWOBJECT is set
  236.     */
  237.  
  238.     if (msg->flags & MADF_DRAWOBJECT)
  239.     {
  240.         WORD bx;
  241.  
  242.         /*
  243.             determine the co-ordinates of the image in the bit map
  244.         */
  245.         bx = (WORD)((data->ImageIdx >= 0  && data->ImageIdx <= IMAGE_COUNT)
  246.                             ? data->Width * data->ImageIdx : 0);
  247.  
  248.         /*
  249.             blit the image from the bitmap to the rastport
  250.         */
  251.         BltBitMapRastPort(data->ImageBM, bx, 0,
  252.                           _rp(obj), (WORD)(_mleft(obj)), (WORD)(_top(obj)),
  253.                           (WORD)data->Width, (WORD)data->Height,
  254.                           (UBYTE)0xC0);
  255.     }
  256.  
  257.     return 0;
  258. }
  259.  
  260.  
  261. SAVEDS ASM ULONG FaceButtonDispatcher(
  262.         REG(a0) struct IClass *cl,
  263.         REG(a2) Object *obj,
  264.         REG(a1) Msg msg)
  265. {
  266.     switch (msg->MethodID)
  267.     {
  268.         case OM_NEW          : return        mNew(cl, obj, (APTR)msg);
  269.         case OM_DISPOSE      : return    mDispose(cl, obj, (APTR)msg);
  270.         case OM_SET          : return        mSet(cl, obj, (APTR)msg);
  271.         case MUIM_Setup      : return      mSetup(cl, obj, (APTR)msg);
  272.         case MUIM_Cleanup    : return    mCleanup(cl, obj, (APTR)msg);
  273.         case MUIM_AskMinMax  : return  mAskMinMax(cl, obj, (APTR)msg);
  274.         case MUIM_Draw       : return       mDraw(cl, obj, (APTR)msg);
  275.     }
  276.  
  277.     return DoSuperMethodA(cl, obj, msg);
  278. }
  279.  
  280.  
  281.  
  282. /*
  283.     function :    frees the memory used for the image file name
  284.  
  285.     parameters :  data = pointer to the FaceButtonData
  286. */
  287. static void DeleteImageFileName(struct FaceButtonData * data)
  288. {
  289.     if (data->ImageFile != NULL)
  290.     {
  291.         FreeVec(data->ImageFile);
  292.         data->ImageFile = NULL;
  293.     }
  294. }
  295.  
  296.  
  297. /*
  298.     function :    delete any existing image file name, sets the given new
  299.                   image file name and sets the new image flag so the new
  300.                   image file is used next time the window is opened
  301.  
  302.     parameters :  data = pointer to the FaceButtonData
  303.                   newname = the new image file name or NULL to clear the
  304.                             existing file name and use the default image
  305.  
  306. */
  307. static void SetImageFileName(struct FaceButtonData * data, STRPTR newname)
  308. {
  309.     DeleteImageFileName(data);
  310.  
  311.     if (newname)
  312.     {
  313.         int l = strlen(newname) + 1;
  314.         data->ImageFile = (STRPTR)AllocVec(l, 0);
  315.         if (data->ImageFile)
  316.         {
  317.             strcpy(data->ImageFile, newname);
  318.         }
  319.     }
  320.  
  321.     data->Flags |= FBDF_NEWIMAGE;
  322. }
  323.  
  324.  
  325. /*
  326.     function :    loads the bitmap used for rendering the button faces
  327.  
  328.     parameters :  data = pointer to the FaceButton data to initialize bitmap for
  329.                   rscreen = pointer to the screen to render the bitmap to
  330.                   fname = name of the image file
  331.  
  332.     return :      TRUE if bitmap initialized ok, FALSE if an error occured
  333. */
  334. BOOL LoadFaceButtonImageBM(struct FaceButtonData * data,
  335.                            struct Screen * rscreen,
  336.                            STRPTR fname)
  337. {
  338.     struct LoadBitMapData lbmdata;
  339.     int rc;
  340.  
  341.     lbmdata.FileName = fname;
  342.     lbmdata.Screen = rscreen;
  343.  
  344.     rc = LoadBitMap(&lbmdata);
  345.     if (rc == LBMERR_NONE)
  346.     {
  347.         if ((lbmdata.BitMapHeader->bmh_Width % IMAGE_COUNT) == 0)
  348.         {
  349.             data->Width  = lbmdata.BitMapHeader->bmh_Width / IMAGE_COUNT;
  350.             data->Height = lbmdata.BitMapHeader->bmh_Height;
  351.             data->RenderScreen = rscreen;
  352.             data->ImageDTObject = lbmdata.DTObject;
  353.             data->ImageBM = lbmdata.BitMap;
  354.             return TRUE;
  355.         }
  356.         else
  357.         {
  358.             DisposeDTObject(lbmdata.DTObject);
  359.         }
  360.     }
  361.     return FALSE;
  362. }
  363.  
  364. /*
  365.     function :    initialize the bitmap used for rendering the button faces
  366.  
  367.     parameters :  data = pointer to the FaceButton data to initialize bitmap for
  368.                   rscreen = pointer to the screen to render the bitmap to
  369.  
  370.     return :      TRUE if bitmap initialized ok, FALSE if an error occured
  371. */
  372. BOOL InitFaceButtonImageBM(struct FaceButtonData * data, struct Screen * rscreen)
  373. {
  374.     BOOL rc = TRUE;
  375.     if (data->RenderScreen == NULL  ||  rscreen != data->RenderScreen  ||
  376.         (data->Flags & FBDF_NEWIMAGE) != 0)
  377.     {
  378.         data->Flags &= ~FBDF_NEWIMAGE;
  379.         FreeFaceButtonImageBM(data);
  380.         rc = LoadFaceButtonImageBM(data, rscreen, (data->ImageFile)
  381.                                                         ? data->ImageFile
  382.                                                         : DEFAULT_IMAGEFILE);
  383.         if (!rc  &&  data->ImageFile)
  384.         {
  385.             rc = LoadFaceButtonImageBM(data, rscreen, DEFAULT_IMAGEFILE);
  386.         }
  387.     }
  388.  
  389.     return rc;
  390. }
  391.  
  392. /*
  393.     function :    frees bitmap data allocated by InitFaceButtonImageBM()
  394.  
  395.     parameters :  data = pointer to the FaceButton data to free bitmap for
  396.  
  397.     return :      none
  398. */
  399. void FreeFaceButtonImageBM(struct FaceButtonData * data)
  400. {
  401.     WaitBlit();
  402.     if (data->ImageDTObject)
  403.     {
  404.         DisposeDTObject(data->ImageDTObject);
  405.         data->ImageDTObject = NULL;
  406.     }
  407.     data->RenderScreen = NULL;
  408.     data->ImageBM = NULL;
  409. }
  410.  
  411.  
  412. /*
  413.     function :    creates the FaceButton MUI custom class
  414.  
  415.     return :      pointer to the created custom class or NULL
  416. */
  417. struct MUI_CustomClass * CreateFaceButtonClass()
  418. {
  419.     return MUI_CreateCustomClass(NULL, MUIC_Area, NULL,
  420.                                        sizeof(struct FaceButtonData),
  421.                                        FaceButtonDispatcher);
  422. }
  423.  
  424. /*
  425.     function :    deletes of the FaceButton custom class
  426.  
  427.     parameters :  mcc = pointer to the FaceButton MUI_CustomClass to delete
  428. */
  429. void DeleteFaceButtonClass(struct MUI_CustomClass * mcc)
  430. {
  431.     MUI_DeleteCustomClass(mcc);
  432. }
  433.  
  434.